# -*- coding: utf-8 -*-
import tracebackfrom mod_log import loggerimport copyimport jsonimport mathimport randomimport timefrom legendaryPowerScript._lpcommon import apiUtilfrom legendaryPowerScript._lpcommon.vector import Vector# from legendaryPowerScript.item.itemTypes import ItemType# from legendaryPowerScript.creatures import Creaturefrom legendaryPowerScript.item.tags import itemTagTypeclass LegendaryItem:
    def __init__(self, itemDict, skipGenerate=False, vanillaSlot=None, shouldClone=True):
        """
        物品
        每个物品都有一个物品类型（ItemType)，大部分属性均从物品类型中获得
        但各个物品可以有一些自定义的属性，如宝石、强化、词条等。这些属性在这个类中定义

        Attributes:
            type (ItemType): 物品类型
            typeName (str): 物品类型名称
            itemDict (dict): 序列化的物品信息，用于访问网易接口，与客户端通讯，或是保存到存档中
            enhance (int): 强化等级
            breakMultiplier (float): 突破时额外增加的属性、词条倍率
            quality (Quality): 物品品质，配置于item/config.yml中
            amount (int): 物品数量，若要更改请调用item.setAmount()函数，不要直接改！
            stats (dict[str, Stat]): 物品的属性
            baseStats (dict[str, Stat]): 物品的基础属性，未受倍率、强化、品质等影响的基础数值
            jades (list[tuple[str, int]]): 物品安装的宝石
            obfuscate (bool): 是否在生成描述时，隐藏物品的品质
            obfuscateEnhance (bool): 是否在生成描述时，隐藏物品的强化等级
            newIndicator (bool): 是否在背包中标识为“新”
            tags (dict[ItemTagType, int]): 物品词条，以及词条等级
            lockedTrade (bool): 是否是绑定物品
            ownedPlayer (Creature): 拥有该物品的玩家
            enhanceXp (int): 强化已有的经验值
            mainTagIndex (int): 主词条序号
            blockCopy (bool): 是否此物品可以在重铸时被提取词条
            stars (int): 星级。若定义了，会覆盖掉ItemType中定义的星级
        """
        self.type = ItemType()  # type: ItemType
        self.typeName = ""  # type: str
        self.itemDict = {}  # type: dict
        self.enhance = 0  # type: int
        self.breakMultiplier = 0.0  # type: float
        self.quality = Quality()  # type: Quality
        self.amount = 0  # type: int
        self.stats = {}  # type: dict[str, Stat]
        self.baseStats = {}  # type: dict[str, Stat]
        self.jades = []  # type: list[tuple[str, int]]
        self.obfuscate = False  # type: bool
        self.obfuscateEnhance = False  # type: bool
        self.newIndicator = False  # type: bool
        self.tags = {}  # type: dict[ItemTagType, int]
        self.lockedTrade = False  # type: bool
        self.ownedPlayer = Creature()  # type: Creature
        self.enhanceXp = 0  # type: int
        self.mainTagIndex = 0  # type: int
        self.blockCopy = False  # type: bool
        self.stars = 0  # type: int
        pass

    def getEnhanceExpMax(self, level=None):
        # type: (int) -> int
        """
        获取装备强化经验上限。

        参数：
            - level (int)：指定的强化等级（默认为 None，表示使用当前装备的强化等级）。

        返回：
            - maxExp (int)：装备强化经验上限。
        """
        pass

    def getVanillaDesc(self):
        # type: () -> list
        """
        获取物品原版的描述。

        返回：
            - desc (list)：包含物品类型显示名称的列表。
        """
        pass

    def getItemAfterAddXp(self, xp):
        # type: (int) -> tuple
        """
        在增加给定的强化经验后，获取强化后的装备的强化等级和剩余经验。
        参数：
            - xp (int)：增加的经验值。

        返回：
            - result (tuple)：包含装备的强化等级和剩余经验的元组。
        """
        pass

    def calculatePower(self, power, checkRank=True):
        # type: (float, bool) -> float
        """
        计算装备的战斗力。

        参数：
            - power (float)：基础战斗力。
            - checkRank (bool)：是否考虑装备的品阶（默认为 True）。

        返回：
            - calculatedPower (float)：计算后的战斗力。
        """
        pass

    def setAmount(self, amount):
        # type: (int) -> None
        """
        设置物品的数量。

        参数：
            - amount (int)：物品的数量。
        """
        pass

    def toGetItemParameters(self, includeAmount=True):
        # type: (bool) -> str
        """
        返回一个表示该物品参数的字符串。

        参数：
            - includeAmount (bool)：是否包含数量，默认为True

        返回：
            - s (str)：表示物品参数的字符串
        """
        pass

    def satisfyParam(self, param):
        # type: (list) -> bool
        """
        检查物品是否满足给定的参数条件。

        参数：
            - param (list)：参数列表，包含物品类型和条件

        返回：
            - bool：是否满足条件
        """
        pass

    def setBound(self, bound):
        # type: (bool) -> None
        """
        设置物品的交易状态。

        参数：
            - bound (bool)：是否绑定

        返回：
            None
        """
        pass

    def getExtraData(self, addClient=True):
        # type: (bool) -> str/dict
        """
        获取物品的额外数据。

        参数：
            - addClient (bool)：是否添加客户端数据，默认为True

        返回：
            - extraData (str/dict)：物品的额外数据，如果addClient为True，则返回字符串形式的JSON，否则返回字典形式的数据
        """
        pass

    def isWarSoulUnlocked(self, index):
        # type: (int) -> bool
        """
        判断战魂是否已解锁。

        参数：
            - index (int)：战魂的索引

        返回：
            - bool：如果战魂已解锁，则为True；否则为False。
        """
        pass

    def __eq__(self, other):
        # type: (object) -> bool
        """
        判断另一个LegendaryItem或是itemDict对象是否与当前物品是一样的物品。注意：不会判断数量！

        参数：
            - other (object)：要与当前LegendaryItem对象比较的对象

        返回：
            - bool：如果另一个对象等于当前物品，则返回True；否则返回False。
        """
        pass

    def getItemName(self):
        # type: () -> str
        """
        获取当前物品的名称。

        返回：
            - str: 当前物品的名称。
        """
        pass

    def clone(self):
        # type: () -> LegendaryItem
        """
        返回当前LegendaryItem对象的深度复制。

        返回：
            - LegendaryItem: 当前LegendaryItem对象的深度副本。
        """
        pass

    def isEquipment(self):
        # type: () -> bool
        """
        判断当前物品是否为装备。

        返回：
            - bool: 如果当前物品是装备，则返回True；否则返回False。
        """
        pass

    def buildStats(self):
        # type: () -> None
        """
        构建并更新当前LegendaryItem对象的属性。

        返回：
            - None
        """
        pass

    def get(self, key, default=None):
        # type: (any, any) -> any
        """
        获取itemDict中指定key的值。

        参数：
            - key (any)：要获取值的键
            - default (any): 如果未找到键，则返回默认值

        返回：
            - any: 指定键的值；如果未找到键，则返回默认值。
        """
        pass

    def __getitem__(self, item):
        # type: (any, any) -> any
        """
        获取itemDict中指定key的值。

        参数：
            - key (any)：要获取值的键
            - default (any): 如果未找到键，则返回默认值

        返回：
            - any: 指定键的值；如果未找到键，则返回默认值。
        """
        pass

    def __setitem__(self, key, value):
        # type: (任意类型, 任意类型) -> 无返回值
        """
        将给定的键和值添加到itemDict字典中，并更新Vanilla。

        参数：
            - key (任意类型)：要添加的键。
            - value (任意类型)：要添加的值。

        返回：
            无返回值
        """
        pass

    def __delitem__(self, key):
        # type: (任意类型) -> 无返回值
        """
        从itemDict字典中删除给定的键。

        参数：
            - key (任意类型)：要删除的键。

        返回：
            无返回值
        """
        pass

    def refreshTooltip(self, comparedTo=None, player=None, obfuscateQuality=None):
        # type: (None或Item对象，默认为None, None或Player对象，默认为None, None、True或False，默认为None) -> 无返回值
        """
        刷新工具提示信息。

        参数：
            - comparedTo (None或Item对象，默认为None)：与之进行比较的物品对象。
            - player (None或Player对象，默认为None)：拥有物品的玩家对象。
            - obfuscateQuality (None、True或False，默认为None)：是否隐藏品质相关信息。

        返回：
            无返回值
        """
        pass

    def handleVariable(self, desc, player):
        # type: (str, object) -> str
        """
        处理物品描述中可能存在的变量，并将其替换为真实值。

        参数：
            - desc (str)：物品描述
            - player (object)：玩家对象

        返回：
            - str：替换后的物品描述
        """
        pass

    def isTradable(self):
        # type: () -> str or None
        """
        判断物品是否可以交易。

        参数：
            无

        返回：
            - str or None：如果该物品无法交易，将返回提示信息，否则返回None。
        """
        pass

    def use(self, creature, category, slot, fromInv=False):
        # type: (object, int, int, bool) -> bool
        """
        使用道具。

        参数：
            - creature (object)：角色对象
            - category (int)：道具所在的快捷栏类别编号
            - slot (int)：道具所在的快捷栏格子编号
            - fromInv (bool)：是否从背包使用该物品，默认值为False

        返回：
            - bool：是否使用成功
        """
        pass

    def getStat(self, stat, default):
        # type: (str, float) -> Stat
        """
        获取物品对象具体属性的值。

        参数：
            - stat (str)：属性名称
            - default (float)：默认值

        返回：
            - Stat：具体属性的对象
        """
        pass

    def getStatAmount(self, stat, default=.0):
        # type: (str, float) -> float
        """
        返回所查询属性的值，如果不存在返回默认值

        参数：
            - stat (str)：查询的属性名称
            - default (float)：默认返回值，默认为0.0

        返回：
            - float：所查询的属性的数值，float类型
        """
        pass

    def giveToPlayer(self, creature):
        # type: (object) -> None
        """
        将self对象给予creature所代表的玩家

        参数：
            - creature (object)：表示一个玩家角色
        """
        pass

    def setQuality(self, quality):
        # type: (object) -> None
        """
        设置物品的品质

        参数：
            - quality (object)：表示物品的品质, 类型为 Quality

        返回：
            - 无
        """
        pass

    def SetJade(self, index, jade, level=1):
        # type: (int, object, int) -> None
        """
        设置物品镶嵌的宝石

        参数：
            - index (int)：宝石的位置
            - jade (object)：宝石的类型，可输入 LegendaryItem 或 ItemType
            - level (int)：宝石的等级，默认为1

        返回：
            - 无
        """
        pass

    def setEnhance(self, enhance):
        # type: (int/float) -> None
        """
        设置物品的强化等级

        参数：
            - enhance (int/float)：物品的强化等级

        返回：
            - 无
        """
        pass

    def shouldAddTag(self):
        # type: () -> bool
        """
        判断是否可以添加物品属性标签

        参数：
            - 无

        返回：
            - bool：返回True，表示可以添加，返回False，表示不可添加
        """
        pass

    def addSideStat(self):
        # type: () -> None
        """
        添加物品属性标签

        参数：
            - 无

        返回：
            - 无
        """
        pass

    def dropAt(self, dropLoc, boundTo=None, register=True, suffix=None):
        # type: (Vector, Creature) -> int
        """
        将物品在指定位置进行丢弃

        参数：
            - dropLoc (Vector)：丢弃位置的坐标向量
            - boundTo (Creature)：绑定的角色对象，默认为None
            - register (bool)：是否注册物品，默认为True
            - suffix (str)：物品名称后缀，默认为None

        返回：
            - int：生成的物品实体ID
        """
        pass

    def _syncItemEntityName(self, spawnedItemId, boundTo, location, suffix=None):
        # type: (int, int/Creature, Vector, str) -> None
        """
        同步物品实体名称到玩家客户端

        参数：
            - spawnedItemId (int)：生成的物品实体ID
            - boundTo (int/Creature)：绑定的角色ID或角色对象
            - location (Vector)：丢弃位置的坐标向量
            - suffix (str)：物品名称后缀，默认为None

        返回：
            - 无
        """
        pass

    def __str__(self):
        # type: () -> str
        """
        返回物品的显示名称

        参数：
            - 无

        返回：
            - str：物品的显示名称，包括数量
        """
        pass

    def getDisplayName(self, includeAmount=True):
        # type: (bool) -> str
        """
        返回物品的显示名称

        参数：
            - includeAmount (bool)：是否包括数量，默认为True

        返回：
            - str：物品的显示名称，可能包括数量
        """
        pass

    def fromParam(cls, itemParam, reciever=None, skipGenerate=False):
        # type: (str or list[str], Creature or None) -> LegendaryItem
        """
        根据物品表达式生成一个物品实例。
        物品表达式：格式与 legendaryItem.toGetItemParameters() 的返回值 和指令 .lp l 及 .lp g 中的格式相同。以下是一些参考：
            大剑 1 +20 优良 锋利|1 _红宝石_2： 一把“大剑”物品，强化+20，优良品质，带有词条“锋利”1级，带有宝石“红宝石”2级
        Args:
            itemParam (str or list[str]): 物品表达式。格式与 legendaryItem.toGetItemParameters() 的返回值 和指令 .lp l 及 .lp g 中的格式相同
            reciever (Creature or None): 接收的玩家，用于处理属性对比等效果
        Returns:
            item (LegendaryItem): 生成的物品
        """
        pass

    def serialize(self, isSave):  # 把物品序列化
        # type: (bool) -> dict
        """
        将物品序列化成itemDict。

        参数：
            - isSave (bool)：指示是否为保存操作。

        返回：
            - itemDict (dict)：序列化后的物品字典。
        """
        pass

